home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 0.9.1.3 stable / flock-0.9.1.3.en-US.win32.exe / flock / components / FeedConverter.js < prev    next >
Text File  |  2007-10-12  |  21KB  |  619 lines
  1. //@line 38 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  2.  
  3. const Cc = Components.classes;
  4. const Ci = Components.interfaces;
  5. const Cr = Components.results;
  6.  
  7. function LOG(str) {
  8.   dump("*** " + str + "\n");
  9. }
  10.  
  11. const FC_CLASSID = Components.ID("{229fa115-9412-4d32-baf3-2fc407f76fb1}");
  12. const FC_CLASSNAME = "Feed Stream Converter";
  13. const FS_CLASSID = Components.ID("{2376201c-bbc6-472f-9b62-7548040a61c6}");
  14. const FS_CLASSNAME = "Feed Result Service";
  15. const FS_CONTRACTID = "@mozilla.org/browser/feeds/result-service;1";
  16. const FPH_CONTRACTID = "@mozilla.org/network/protocol;1?name=feed";
  17. const FPH_CLASSID = Components.ID("{4f91ef2e-57ba-472e-ab7a-b4999e42d6c0}");
  18. const FPH_CLASSNAME = "Feed Protocol Handler";
  19. const PCPH_CONTRACTID = "@mozilla.org/network/protocol;1?name=pcast";
  20. const PCPH_CLASSID = Components.ID("{1c31ed79-accd-4b94-b517-06e0c81999d5}");
  21. const PCPH_CLASSNAME = "Podcast Protocol Handler";
  22. const FHS_CONTRACTID = "@mozilla.org/browser/feeds/handler-service;1";
  23. const FHS_CLASSID = Components.ID("{792a7e82-06a0-437c-af63-b2d12e808acc}");
  24. const FHS_CLASSNAME = "Feed Handler Service";
  25.  
  26. const TYPE_MAYBE_FEED = "application/vnd.mozilla.maybe.feed";
  27. const TYPE_ANY = "*/*";
  28.  
  29. //const FEEDHANDLER_URI = "about:feeds";
  30. const FEEDHANDLER_URI = "flock://preview/";
  31.  
  32. const PREF_SELECTED_APP = "browser.feeds.handlers.application";
  33. const PREF_SELECTED_WEB = "browser.feeds.handlers.webservice";
  34. const PREF_SELECTED_ACTION = "browser.feeds.handler";
  35. const PREF_SELECTED_READER = "browser.feeds.handler.default";
  36.  
  37. function safeGetBoolPref(pref, defaultValue) {
  38.   var prefs =   
  39.       Cc["@mozilla.org/preferences-service;1"].
  40.       getService(Ci.nsIPrefBranch);
  41.   try {
  42.     return prefs.getBoolPref(pref);
  43.   }
  44.   catch (e) {
  45.   }
  46.   return defaultValue;
  47. }
  48.  
  49. function safeGetCharPref(pref, defaultValue) {
  50.   var prefs =   
  51.       Cc["@mozilla.org/preferences-service;1"].
  52.       getService(Ci.nsIPrefBranch);
  53.   try {
  54.     return prefs.getCharPref(pref);
  55.   }
  56.   catch (e) {
  57.   }
  58.   return defaultValue;
  59. }
  60.  
  61. function FeedConverter() {
  62. }
  63. FeedConverter.prototype = {
  64.   /**
  65.    * This is the downloaded text data for the feed.
  66.    */
  67.   _data: null,
  68.   
  69.   /**
  70.    * This is the object listening to the conversion, which is ultimately the
  71.    * docshell for the load.
  72.    */
  73.   _listener: null,
  74.  
  75.   /**
  76.    * Records if the feed was sniffed
  77.    */
  78.   _sniffed: false,
  79.   
  80.   /**
  81.    * See nsIStreamConverter.idl
  82.    */
  83.   canConvert: function FC_canConvert(sourceType, destinationType) {
  84.     // We only support one conversion.
  85.     return destinationType == TYPE_ANY && sourceType == TYPE_MAYBE_FEED;
  86.   },
  87.   
  88.   /**
  89.    * See nsIStreamConverter.idl
  90.    */
  91.   convert: function FC_convert(sourceStream, sourceType, destinationType, 
  92.                                context) {
  93.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  94.   },
  95.   
  96.   /**
  97.    * See nsIStreamConverter.idl
  98.    */
  99.   asyncConvertData: function FC_asyncConvertData(sourceType, destinationType,
  100.                                                  listener, context) {
  101.     this._listener = listener;
  102.   },
  103.   
  104.   /**
  105.    * Whether or not the preview page is being forced.
  106.    */
  107.   _forcePreviewPage: false,
  108.  
  109.   /** 
  110.    * Release our references to various things once we're done using them.
  111.    */
  112.   _releaseHandles: function FC__releaseHandles() {
  113.     this._listener = null;
  114.     this._request = null;
  115.   },
  116.  
  117.   /**
  118.    * See nsIFeedResultListener.idl
  119.    */
  120.   handleResult: function FC_handleResult(result) {
  121.     // Feeds come in various content types, which our feed sniffer coerces to
  122.     // the maybe.feed type. However, feeds are used as a transport for 
  123.     // different data types, e.g. news/blogs (traditional feed), video/audio
  124.     // (podcasts) and photos (photocasts, photostreams). Each of these is 
  125.     // different in that there's a different class of application suitable for
  126.     // handling feeds of that type, but without a content-type differentiation
  127.     // it is difficult for us to disambiguate.
  128.     // 
  129.     // The other problem is that if the user specifies an auto-action handler
  130.     // for one feed application, the fact that the content type is shared means 
  131.     // that all other applications will auto-load with that handler too, 
  132.     // regardless of the content-type. 
  133.     //
  134.     // This means that content-type alone is not enough to determine whether
  135.     // or not a feed should be auto-handled. This means that for feeds we need
  136.     // to always use this stream converter, even when an auto-action is 
  137.     // specified, not the basic one provided by WebContentConverter. This 
  138.     // converter needs to consume all of the data and parse it, and based on
  139.     // that determination make a judgement about type. 
  140.     //
  141.     // Since there are no content types for this content, and I'm not going to
  142.     // invent any, the upshot is that while a user can set an auto-handler for
  143.     // generic feed content, the system will prevent them from setting an auto-
  144.     // handler for other stream types. In those cases, the user will always see
  145.     // the preview page and have to select a handler. We can guess and show 
  146.     // a client handler, but will not be able to show web handlers for those
  147.     // types.
  148.     //
  149.     // If this is just a feed, not some kind of specialized application, then
  150.     // auto-handlers can be set and we should obey them. 
  151.     try {
  152.       var feedService = 
  153.           Cc["@mozilla.org/browser/feeds/result-service;1"].
  154.           getService(Ci.nsIFeedResultService);
  155.       if (!this._forcePreviewPage && result.doc) {
  156.         var handler = safeGetCharPref(PREF_SELECTED_ACTION, "ask");
  157.         if (handler != "ask") {
  158.           if (handler == "reader")
  159.             handler = safeGetCharPref(PREF_SELECTED_READER, "bookmarks");
  160.           switch (handler) {
  161.             case "web":
  162.               var wccr = 
  163.                   Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].
  164.                   getService(Ci.nsIWebContentConverterService);
  165.               var feed = result.doc.QueryInterface(Ci.nsIFeed);
  166.               if (feed.type == Ci.nsIFeed.TYPE_FEED &&
  167.                   wccr.getAutoHandler(TYPE_MAYBE_FEED)) {
  168.                 wccr.loadPreferredHandler(this._request);
  169.                 return;
  170.               }
  171.               break;
  172.  
  173.             default:
  174.               LOG("unexpected handler: " + handler);
  175.               // fall through -- let feed service handle error
  176.             case "bookmarks":
  177.             case "client":
  178.               try {
  179.                 var feed = result.doc.QueryInterface(Ci.nsIFeed);
  180.                 var title = feed.title ? feed.title.plainText() : "";
  181.                 var desc = feed.subtitle ? feed.subtitle.plainText() : "";
  182.                 feedService.addToClientReader(result.uri.spec, title, desc);
  183.                 return;
  184.               }
  185.               catch(ex) { /* fallback to preview mode */ }
  186.           }
  187.         }
  188.       }
  189.  
  190.       var ios = 
  191.            Cc["@mozilla.org/network/io-service;1"].
  192.            getService(Ci.nsIIOService);
  193.       var chromeChannel;
  194.  
  195.       // show the feed page if it wasn't sniffed and we have a document,
  196.       // or we have a document, title, and link or id
  197.       if (result.doc && (!this._sniffed ||
  198.           (result.doc.title && (result.doc.link || result.doc.id)))) {
  199.         // If there was no automatic handler, or this was a podcast,
  200.         // photostream or some other kind of application, we must always
  201.         // show the preview page...
  202.  
  203.         // Store the result in the result service so that the display page can 
  204.         // access it.
  205.         //feedService.addFeedResult(result);
  206.         
  207.         var feedManager = Components.classes["@flock.com/feed-manager;1"].getService(Components.interfaces.flockIFeedManager);
  208.         if (feedManager.getFeedContext("news").existsSubscription(this._request.originalURI)) {
  209.             var chromeURI = ios.newURI("flock://favorites/" + encodeURIComponent("urn:flock:feed:" + this._request.originalURI.spec), null, null);
  210.             chromeChannel = ios.newChannelFromURI(chromeURI, null);
  211.             chromeChannel.originalURI = chromeURI;
  212.         } else {
  213.           feedManager.storeFeed(this._request.originalURI, result);
  214.           var chromeURI = ios.newURI("flock://preview/" + encodeURIComponent(this._request.originalURI.spec), null, null);
  215.             chromeChannel = ios.newChannelFromURI(chromeURI, null);
  216.             chromeChannel.originalURI = this._request.originalURI;
  217.         }
  218.       }
  219.       else
  220.         chromeChannel = ios.newChannelFromURI(result.uri, null);
  221.  
  222.       chromeChannel.loadGroup = this._request.loadGroup;
  223.       chromeChannel.asyncOpen(this._listener, null);
  224.     }
  225.     finally {
  226.       this._releaseHandles();
  227.     }
  228.   },
  229.   
  230.   /**
  231.    * See nsIStreamListener.idl
  232.    */
  233.   onDataAvailable: function FC_onDataAvailable(request, context, inputStream, 
  234.                                                sourceOffset, count) {
  235.     this._processor.onDataAvailable(request, context, inputStream,
  236.                                     sourceOffset, count);
  237.   },
  238.   
  239.   /**
  240.    * See nsIRequestObserver.idl
  241.    */
  242.   onStartRequest: function FC_onStartRequest(request, context) {
  243.     var channel = request.QueryInterface(Ci.nsIChannel);
  244.  
  245.     // Check for a header that tells us there was no sniffing
  246.     // The value doesn't matter.
  247.     try {
  248.       var httpChannel = channel.QueryInterface(Ci.nsIHttpChannel);
  249.       var noSniff = httpChannel.getResponseHeader("X-Moz-Is-Feed");
  250.     }
  251.     catch (ex) {
  252.       this._sniffed = true;
  253.     }
  254.  
  255.     this._request = request;
  256.     
  257.     // Save and reset the forced state bit early, in case there's some kind of
  258.     // error.
  259.     var feedService = 
  260.         Cc["@mozilla.org/browser/feeds/result-service;1"].
  261.         getService(Ci.nsIFeedResultService);
  262.     this._forcePreviewPage = feedService.forcePreviewPage;
  263.     feedService.forcePreviewPage = false;
  264.  
  265.     // Parse feed data as it comes in
  266.     this._processor =
  267.         Cc["@mozilla.org/feed-processor;1"].
  268.         createInstance(Ci.nsIFeedProcessor);
  269.     this._processor.listener = this;
  270.     this._processor.parseAsync(null, channel.URI);
  271.     
  272.     this._processor.onStartRequest(request, context);
  273.   },
  274.   
  275.   /**
  276.    * See nsIRequestObserver.idl
  277.    */
  278.   onStopRequest: function FC_onStopRequest(request, context, status) {
  279.     this._processor.onStopRequest(request, context, status);
  280.   },
  281.   
  282.   /**
  283.    * See nsISupports.idl
  284.    */
  285.   QueryInterface: function FC_QueryInterface(iid) {
  286.     if (iid.equals(Ci.nsIFeedResultListener) ||
  287.         iid.equals(Ci.nsIStreamConverter) ||
  288.         iid.equals(Ci.nsIStreamListener) ||
  289.         iid.equals(Ci.nsIRequestObserver)||
  290.         iid.equals(Ci.nsISupports))
  291.       return this;
  292.     throw Cr.NS_ERROR_NO_INTERFACE;
  293.   },
  294. };
  295.  
  296. var FeedConverterFactory = {
  297.   createInstance: function FS_createInstance(outer, iid) {
  298.     if (outer != null)
  299.       throw Cr.NS_ERROR_NO_AGGREGATION;
  300.     return new FeedConverter().QueryInterface(iid);
  301.   },
  302.  
  303.   QueryInterface: function FS_QueryInterface(iid) {
  304.     if (iid.equals(Ci.nsIFactory) ||
  305.         iid.equals(Ci.nsISupports))
  306.       return this;
  307.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  308.   },
  309. };
  310.  
  311. /**
  312.  * Keeps parsed FeedResults around for use elsewhere in the UI after the stream
  313.  * converter completes. 
  314.  */
  315. var FeedResultService = {
  316.   
  317.   /**
  318.    * A URI spec -> [nsIFeedResult] hash. We have to keep a list as the
  319.    * value in case the same URI is requested concurrently.
  320.    */
  321.   _results: { },
  322.   
  323.   /**
  324.    * See nsIFeedService.idl
  325.    */
  326.   forcePreviewPage: false,
  327.   
  328.   /**
  329.    * See nsIFeedService.idl
  330.    */
  331.   addToClientReader: function FRS_addToClientReader(spec, title, subtitle) {
  332.     var prefs =   
  333.         Cc["@mozilla.org/preferences-service;1"].
  334.         getService(Ci.nsIPrefBranch);
  335.  
  336.     var handler = safeGetCharPref(PREF_SELECTED_ACTION, "bookmarks");
  337.     if (handler == "ask" || handler == "reader")                                
  338.       handler = safeGetCharPref(PREF_SELECTED_READER, "bookmarks");             
  339.  
  340.     switch (handler) {
  341.     case "client":
  342.       var clientApp = 
  343.         prefs.getComplexValue(PREF_SELECTED_APP, Ci.nsILocalFile);
  344. //@line 401 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  345.       var ss = 
  346.           Cc["@mozilla.org/browser/shell-service;1"].
  347.           getService(Ci.nsIShellService_MOZILLA_1_8_BRANCH);
  348.       ss.openApplicationWithURI(clientApp, spec);
  349.       break;
  350.  
  351.     default:
  352.       // "web" should have been handled elsewhere
  353.       LOG("unexpected handler: " + handler);
  354.       // fall through
  355.     case "bookmarks":
  356.       var wm = 
  357.           Cc["@mozilla.org/appshell/window-mediator;1"].
  358.           getService(Ci.nsIWindowMediator);
  359.       var topWindow = wm.getMostRecentWindow("navigator:browser");
  360. //@line 419 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  361.       topWindow.FeedHandler.addLiveBookmark(spec, title, subtitle);
  362. //@line 421 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  363.       break;
  364.     }
  365.   },
  366.   
  367.   /**
  368.    * See nsIFeedService.idl
  369.    */
  370.   addFeedResult: function FRS_addFeedResult(feedResult) {
  371.     NS_ASSERT(feedResult.uri != null, "null URI!");
  372.     NS_ASSERT(feedResult.uri != null, "null feedResult!");
  373.     var spec = feedResult.uri.spec;
  374.     if(!this._results[spec])  
  375.       this._results[spec] = [];
  376.     this._results[spec].push(feedResult);
  377.   },
  378.   
  379.   /**
  380.    * See nsIFeedService.idl
  381.    */
  382.   getFeedResult: function RFS_getFeedResult(uri) {
  383.     NS_ASSERT(uri != null, "null URI!");
  384.     var resultList = this._results[uri.spec];
  385.     for (var i in resultList) {
  386.       if (resultList[i].uri == uri)
  387.         return resultList[i];
  388.     }
  389.     return null;
  390.   },
  391.   
  392.   /**
  393.    * See nsIFeedService.idl
  394.    */
  395.   removeFeedResult: function FRS_removeFeedResult(uri) {
  396.     NS_ASSERT(uri != null, "null URI!");
  397.     var resultList = this._results[uri.spec];
  398.     if (!resultList)
  399.       return;
  400.     var deletions = 0;
  401.     for (var i = 0; i < resultList.length; ++i) {
  402.       if (resultList[i].uri == uri) {
  403.         delete resultList[i];
  404.         ++deletions;
  405.       }
  406.     }
  407.     
  408.     // send the holes to the end
  409.     resultList.sort();
  410.     // and trim the list
  411.     resultList.splice(resultList.length - deletions, deletions);
  412.     if (resultList.length == 0)
  413.       delete this._results[uri.spec];
  414.   },
  415.  
  416.   createInstance: function FRS_createInstance(outer, iid) {
  417.     if (outer != null)
  418.       throw Cr.NS_ERROR_NO_AGGREGATION;
  419.     return this.QueryInterface(iid);
  420.   },
  421.   
  422.   QueryInterface: function FRS_QueryInterface(iid) {
  423.     if (iid.equals(Ci.nsIFeedResultService) ||
  424.         iid.equals(Ci.nsIFactory) ||
  425.         iid.equals(Ci.nsISupports))
  426.       return this;
  427.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  428.   },
  429. };
  430.  
  431. /**
  432.  * A protocol handler that converts the URIs of Apple's various bogo protocol
  433.  * schemes into http, as they should be. Mostly, this object just forwards 
  434.  * things through to the HTTP protocol handler.
  435.  */
  436. function FeedProtocolHandler(scheme) {
  437.   this._scheme = scheme;
  438.   var ios = 
  439.       Cc["@mozilla.org/network/io-service;1"].
  440.       getService(Ci.nsIIOService);
  441.   this._http = ios.getProtocolHandler("http");
  442. }
  443. FeedProtocolHandler.prototype = {
  444.   _scheme: "",
  445.   get scheme() {
  446.     return this._scheme;
  447.   },
  448.   
  449.   get protocolFlags() {
  450.     return this._http.protocolFlags;
  451.   },
  452.   
  453.   get defaultPort() {
  454.     return this._http.defaultPort;
  455.   },
  456.   
  457.   allowPort: function FPH_allowPort(port, scheme) {
  458.     return this._http.allowPort(port, scheme);
  459.   },
  460.   
  461.   newURI: function FPH_newURI(spec, originalCharset, baseURI) {
  462.     var uri = 
  463.         Cc["@mozilla.org/network/standard-url;1"].
  464.         createInstance(Ci.nsIStandardURL);
  465.     uri.init(Ci.nsIStandardURL.URLTYPE_STANDARD, 80, spec, originalCharset,
  466.              baseURI);
  467.     return uri;
  468.   },
  469.   
  470.   newChannel: function FPH_newChannel(uri) {
  471.     var ios = 
  472.         Cc["@mozilla.org/network/io-service;1"].
  473.         getService(Ci.nsIIOService);
  474.     // feed: URIs either start feed://, in which case the real scheme is http:
  475.     // or feed:http(s)://, (which by now we've changed to feed://realscheme//)
  476.     const httpsChunk = "feed://https//";
  477.     const httpChunk = "feed://http//";
  478.     if (uri.spec.substr(0, httpsChunk.length) == httpsChunk)
  479.       uri.spec = "https://" + uri.spec.substr(httpsChunk.length);
  480.     else if (uri.spec.substr(0, httpChunk.length) == httpChunk)
  481.       uri.spec = "http://" + uri.spec.substr(httpChunk.length);
  482.     else
  483.       uri.scheme = "http";
  484.  
  485.     var channel =
  486.       ios.newChannelFromURI(uri, null).QueryInterface(Ci.nsIHttpChannel);
  487.     // Set this so we know this is supposed to be a feed
  488.     channel.setRequestHeader("X-Moz-Is-Feed", "1", false);
  489.     channel.originalURI = uri;
  490.     return channel;
  491.   },
  492.   
  493.   QueryInterface: function FPH_QueryInterface(iid) {
  494.     if (iid.equals(Ci.nsIProtocolHandler) ||
  495.         iid.equals(Ci.nsISupports))
  496.       return this;
  497.     throw Cr.NS_ERROR_NO_INTERFACE;
  498.   }  
  499. };
  500.  
  501. var Module = {
  502.   QueryInterface: function M_QueryInterface(iid) {
  503.     if (iid.equals(Ci.nsIModule) ||
  504.         iid.equals(Ci.nsISupports))
  505.       return this;
  506.     throw Cr.NS_ERROR_NO_INTERFACE;
  507.   },
  508.   
  509.   getClassObject: function M_getClassObject(cm, cid, iid) {
  510.     if (!iid.equals(Ci.nsIFactory))
  511.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  512.     
  513.     if (cid.equals(FS_CLASSID))
  514.       return FeedResultService;
  515.     if (cid.equals(FPH_CLASSID))
  516.       return new GenericComponentFactory(FeedProtocolHandler, "feed");
  517.     if (cid.equals(PCPH_CLASSID))
  518.       return new GenericComponentFactory(FeedProtocolHandler, "pcast");
  519.     if (cid.equals(FC_CLASSID))
  520.       return new GenericComponentFactory(FeedConverter);
  521.       
  522.     throw Cr.NS_ERROR_NO_INTERFACE;
  523.   },
  524.   
  525.   registerSelf: function M_registerSelf(cm, file, location, type) {
  526.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  527.     
  528.     cr.registerFactoryLocation(FS_CLASSID, FS_CLASSNAME, FS_CONTRACTID,
  529.                                file, location, type);
  530.     cr.registerFactoryLocation(FPH_CLASSID, FPH_CLASSNAME, FPH_CONTRACTID,
  531.                                file, location, type);
  532.     cr.registerFactoryLocation(PCPH_CLASSID, PCPH_CLASSNAME, PCPH_CONTRACTID,
  533.                                file, location, type);
  534.  
  535.     // The feed converter is always attached, since parsing must be done to 
  536.     // determine whether or not auto-handling can occur. 
  537.     const converterPrefix = "@mozilla.org/streamconv;1?from=";
  538.     var converterContractID = 
  539.         converterPrefix + TYPE_MAYBE_FEED + "&to=" + TYPE_ANY;
  540.     cr.registerFactoryLocation(FC_CLASSID, FC_CLASSNAME, converterContractID,
  541.                                file, location, type);
  542.   },
  543.   
  544.   unregisterSelf: function M_unregisterSelf(cm, location, type) {
  545.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  546.     cr.unregisterFactoryLocation(FPH_CLASSID, location);
  547.     cr.unregisterFactoryLocation(PCPH_CLASSID, location);
  548.   },
  549.   
  550.   canUnload: function M_canUnload(cm) {
  551.     return true;
  552.   }
  553. };
  554.  
  555. function NSGetModule(cm, file) {
  556.   return Module;
  557. }
  558.  
  559. //@line 44 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  560.  
  561. var gTraceOnAssert = true;
  562.  
  563. /**
  564.  * This function provides a simple assertion function for JavaScript.
  565.  * If the condition is true, this function will do nothing.  If the
  566.  * condition is false, then the message will be printed to the console
  567.  * and an alert will appear showing a stack trace, so that the (alpha
  568.  * or nightly) user can file a bug containing it.  For future enhancements, 
  569.  * see bugs 330077 and 330078.
  570.  *
  571.  * To suppress the dialogs, you can run with the environment variable
  572.  * XUL_ASSERT_PROMPT set to 0 (if unset, this defaults to 1).
  573.  *
  574.  * @param condition represents the condition that we're asserting to be
  575.  *                  true when we call this function--should be
  576.  *                  something that can be evaluated as a boolean.
  577.  * @param message   a string to be displayed upon failure of the assertion
  578.  */
  579.  
  580. function NS_ASSERT(condition, message) {
  581.   if (condition)
  582.     return;
  583.  
  584.   var assertionText = "ASSERT: " + message + "\n";
  585.  
  586. //@line 72 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  587.   Components.util.reportError(assertionText);
  588.   return;
  589. //@line 108 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  590. }
  591. //@line 37 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/GenericFactory.js"
  592.  
  593. /**
  594.  * An object implementing nsIFactory that can construct other objects upon
  595.  * createInstance, passing a set of parameters to that object's constructor.
  596.  */
  597. function GenericComponentFactory(ctor, params) {
  598.   this._ctor = ctor;
  599.   this._params = params;
  600. }
  601. GenericComponentFactory.prototype = {
  602.   _ctor: null,
  603.   _params: null,
  604.   
  605.   createInstance: function GCF_createInstance(outer, iid) {
  606.     if (outer != null)
  607.       throw Cr.NS_ERROR_NO_AGGREGATION;
  608.     return (new this._ctor(this._params)).QueryInterface(iid);
  609.   },
  610.   
  611.   QueryInterface: function GCF_QueryInterface(iid) {
  612.     if (iid.equals(Ci.nsIFactory) ||
  613.         iid.equals(Ci.nsISupports)) 
  614.       return this;
  615.     throw Cr.NS_ERROR_NO_INTERFACE;
  616.   }
  617. };
  618.  
  619.